home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 422_02 / misc / kmedit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-20  |  8.9 KB  |  424 lines
  1. /*
  2.  * Kids Menu EDITor
  3.  *
  4.  * Copyright 1993-1994 Dave Dunfield
  5.  *
  6.  * Permission granted for personal (non-commercial) use only.
  7.  *
  8.  * Compile command: cc kmedit -fop
  9.  */
  10. #include <stdio.h>
  11. #include <window.h>
  12.  
  13. #define    MAXPACK    27
  14.  
  15. unsigned active = 0;
  16.  
  17. unsigned char itext[8][6], iattr[8][6], idir[50], icmd[50], attr = 07;
  18.  
  19. unsigned char Itext[MAXPACK][8][6], Iattr[MAXPACK][8][6],
  20.     Idir[MAXPACK][50], Icmd[MAXPACK][50], ifile[50];
  21.  
  22. char *form1[] = {
  23.     70<<8|6,
  24.     "\x01\x01\x31Directory:",
  25.     "\x01\x02\x31Command  :",
  26.     0 };
  27.  
  28. char *form2[] = {
  29.     40<<8|5,
  30.     "\x01\x01\x82Entry number:",
  31.     0 };
  32.  
  33. char *keytext[] = {
  34.     "F1   - Select  graphic character",
  35.     "F2   - Insert last  graphic char",
  36.     "F3   - 'pick up'  a graphic char",
  37.     "F4   - Set new directory/command",
  38.     "F5   - Select new attribute",
  39.     "F6   - Change attribute at cursor",
  40.     "F7   - 'pick up' an attribute",
  41.     "F8   - Change ALL attributes",
  42.     "F9   - Select entry by number",
  43.     "F10  - Copy another entry",
  44.     "Home - Arrange positions",
  45.     "ESC  - Exit program",
  46.     "PgUp - Select next entry",
  47.     "PgDn - Select previous entry",
  48.     0 };
  49.  
  50. char htext[] = {
  51. "Kids Menu EDITor - Copyright 1993-1994 Dave Dunfield, Freely distributable.\n\n\
  52. Use: KMEDIT [file]\n\n\
  53. for Bethany and Michael.\n" };
  54.  
  55. struct WINDOW *MAIN, *ICON;
  56.  
  57. /*
  58.  * Main program
  59.  */
  60. main(argc, argv)
  61.     int argc;
  62.     char *argv[];
  63. {
  64.     unsigned c, l, x, y;
  65.     char *ptr;
  66.     FILE *fp;
  67.  
  68.     get_name(ifile, (argc > 1) ? argv[1] : "KIDSMENU", ".DAT");
  69.  
  70.     memset(Itext, ' ', sizeof(Itext));
  71.     memset(Iattr, attr = NORMAL, sizeof(Iattr));
  72.     memset(Idir, 0, sizeof(Idir));
  73.     memset(Icmd, 0, sizeof(Icmd));
  74.  
  75.     if(fp = fopen(ifile, "rvb")) {
  76.         x = 0;
  77.         do {
  78.             y =  fread(Itext[x], sizeof(itext), fp);
  79.             y += fread(Iattr[x], sizeof(iattr), fp);
  80.             y += fread(Idir[x] , sizeof(idir ), fp);
  81.             y += fread(Icmd[x] , sizeof(icmd ), fp);
  82.             ++x; }
  83.         while(y == (sizeof(itext)+sizeof(iattr)+sizeof(idir)+sizeof(icmd)));
  84.         fclose(fp); }
  85.  
  86.     MAIN = wopen(0, 0, 80, 25, WSAVE|WCOPEN|WBOX1|NORMAL);
  87.     for(x=0; ptr = keytext[x]; ++x) {
  88.         wgotoxy(34, x+5);
  89.         wputs(ptr); }
  90.  
  91.     ICON = wopen(10, 6, 14, 10, WBOX1|WCOPEN|NORMAL);
  92.  
  93. load:
  94.     load_icon(active);
  95.  
  96.     x = y = 0;
  97.  
  98. newtext:
  99.     w_gotoxy(5, 1, MAIN);
  100.     w_printf(MAIN, "Number   : %-5u", active+1);
  101.     w_gotoxy(5, 2, MAIN);
  102.     w_printf(MAIN, "Directory: %-50s", idir);
  103.     w_gotoxy(5, 3, MAIN);
  104.     w_printf(MAIN, "Command  : %-50s", icmd);
  105.     w_gotoxy(12, 18, MAIN);
  106.     *MAIN = attr;
  107.     w_puts("* TEST *", MAIN);
  108.     *MAIN = NORMAL;
  109.     for(;;) {
  110.         draw_icon(2, 1, itext, iattr);
  111.         wgotoxy(x+2, y+1);
  112.         switch(c = wgetc()) {
  113.             case _KUA :    y = y ? y-1 : 5;        break;
  114.             case _KDA :    y = (y < 5) ? y+1 : 0;    break;
  115.             default :
  116.                 itext[x][y] = c;
  117.                 iattr[x][y] = attr;
  118.             case _KRA :    x = (x < 7) ? x+1 : 0;    break;
  119.             case _KLA :    x = x ? x-1 : 7;        break;
  120.             case _K5  :    
  121.                 if(get_attr())
  122.                     iattr[x][y] = attr;            goto newtext;
  123.             case _K6  :    iattr[x][y] = attr;        break;
  124.             case _K7  :    attr = iattr[x][y];        goto newtext;
  125.             case _K3  :    l = itext[x][y];        break;
  126.             case _K8  :
  127.                 memset(iattr, attr, sizeof(iattr));
  128.                 break;
  129.             case _K4  :
  130.                 wform(5, 10, WSAVE|WBOX2|WCOPEN|REVERSE, form1, idir, icmd);
  131.                 goto newtext;
  132.             case _K1 :
  133.                 if((c = get_char()) & 0xFF00)
  134.                     break;
  135.                 goto plunk;
  136.             case _K2 :
  137.                 c = l;
  138.             plunk:
  139.                 itext[x][y] = l = c;
  140.                 iattr[x][y] = attr;
  141.                 break;
  142.             case _K9 :
  143.                 save_icon(active);
  144.                 c = active + 1;
  145.                 wform(10, 10, WSAVE|WCOPEN|WBOX2|REVERSE, form2, &c);
  146.                 if(--c < MAXPACK)
  147.                     active = c;
  148.                 goto load;
  149.             case _K10 :
  150.                 save_icon(active);
  151.                 c = 0;
  152.                 wform(10, 10, WSAVE|WCOPEN|WBOX2|REVERSE, form2, &c);
  153.                 if(--c < MAXPACK)
  154.                     load_icon(c);
  155.                 break;
  156.             case _KPU :
  157.                 save_icon(active);
  158.                 active = (active < (MAXPACK-1)) ? active + 1 : 0;
  159.                 goto load;
  160.             case _KPD :
  161.                 save_icon(active);
  162.                 active = active ? active - 1 : MAXPACK - 1;
  163.                 goto load;
  164.             case _KHO :
  165.                 save_icon(active);
  166.                 arrange();
  167.                 goto load;
  168.             case 0x1B :
  169.                 save_icon(active);
  170.                 if(yesno("Save file")) {
  171.                     fp = fopen(ifile, "wvqb");
  172.                     for(x = 0; x < MAXPACK; ++x) {
  173.                         if(test_icon(x)) {
  174.                             fwrite(Itext[x], sizeof(itext), fp);
  175.                             fwrite(Iattr[x], sizeof(iattr), fp);
  176.                             fwrite(Idir [x], sizeof(idir ), fp);
  177.                             fwrite(Icmd [x], sizeof(icmd ), fp); } }
  178.                     fclose(fp); }
  179.                 if(yesno("Exit Program")) {
  180.                     wclose();
  181.                     wclose();
  182.                     fputs(htext, stdout);
  183.                     return; } } }
  184. }
  185.  
  186. /*
  187.  * Load a saved ICON
  188.  */
  189. load_icon(inum)
  190.     int inum;
  191. {
  192.     memcpy(itext, Itext[inum], sizeof(itext));
  193.     memcpy(iattr, Iattr[inum], sizeof(iattr));
  194.     memcpy(idir , Idir [inum], sizeof(idir ));
  195.     memcpy(icmd , Icmd [inum], sizeof(icmd ));
  196. }
  197.  
  198. /*
  199.  * Save the ICON permanenthy
  200.  */
  201. save_icon(inum)
  202.     int inum;
  203. {
  204.     memcpy(Itext[inum], itext, sizeof(itext));
  205.     memcpy(Iattr[inum], iattr, sizeof(iattr));
  206.     memcpy(Idir [inum], idir , sizeof(idir ));
  207.     memcpy(Icmd [inum], icmd , sizeof(icmd ));
  208. }
  209.  
  210. /*
  211.  * Test to see if an ICON is blank
  212.  */
  213. test_icon(inum)
  214.     int inum;
  215. {
  216.     int i;
  217.     char *ptr;
  218.     if(*Idir[inum] || *Icmd[inum])
  219.         return -1;
  220.     ptr = Itext[inum];
  221.     for(i=0; i < sizeof(itext); ++i)
  222.         if(*ptr++ != ' ')
  223.             return -1;
  224.     return 0;
  225. }
  226.  
  227. /*
  228.  * Display the ICON
  229.  */
  230. draw_icon(x, y, text, attr)
  231.     unsigned x, y;
  232.     unsigned char text[8][6], attr[8][6];
  233. {
  234.     int x1, y1;
  235.  
  236.     for(y1=0; y1 < 6; ++y1) {
  237.         wgotoxy(x, y+y1);
  238.         for(x1 = 0; x1 < 8; ++x1) {
  239.             *W_OPEN = attr[x1][y1];
  240.             wputc((unsigned)text[x1][y1] | 0x0100); } }
  241. }
  242.  
  243. /*
  244.  * Get forground\background color
  245.  */
  246. get_attr()
  247. {
  248.     int c, f, b;
  249.     b = attr >> 4;
  250.     f = attr & 0x0F;
  251.  
  252.     for(;;) {
  253.         wopen(7, 17, 20, 5, WSAVE|WCOPEN|WBOX2|NORMAL);
  254.         wprintf("Forground: %u\nBackground: %u\n", f, b);
  255.         *W_OPEN = (b << 4) | f;
  256.         wputs(" * TEST * ");
  257.         c = wgetc();
  258.         wclose();
  259.         switch(c) {
  260.             case _KUA :
  261.                 f = (f < 15) ? f+1 : 0;
  262.                 break;
  263.             case _KDA :
  264.                 f = f ? f-1 : 15;
  265.                 break;
  266.             case _KRA :
  267.                 b = (b < 15) ? b+1 : 0;
  268.                 break;
  269.             case _KLA :
  270.                 b = b ? b-1 : 15;
  271.                 break;
  272.             case '\n' :
  273.                 attr = (b << 4) | f;
  274.                 return -1;
  275.             case 0x1B :
  276.                 return 0; } }
  277. }
  278.  
  279. /*
  280.  * Choose character
  281.  */
  282. get_char()
  283. {
  284.     unsigned char i;
  285.     static unsigned char ch = 0;
  286.  
  287.     wopen(50, 1, 9, 23, WSAVE|WCOPEN|WBOX3|NORMAL);
  288.  
  289.     for(;;) {
  290.         for(i=0; i < 21; ++i) {
  291.             wgotoxy(0, i);
  292.             *W_OPEN = (i == 10) ? REVERSE : NORMAL;
  293.             wprintf(" %02x -", i + ch);
  294.             *W_OPEN = NORMAL;
  295.             wputc(' ');
  296.             if(i == 10)
  297.                 *W_OPEN = attr;
  298.             wputc((unsigned)(i+ch) | 0x0100); }
  299.         switch(wgetc()) {
  300.             case _KUA :    --ch;        break;
  301.             case _KDA : ++ch;        break;
  302.             case _KPU :    ch -= 20;    break;
  303.             case _KPD :    ch += 20;    break;
  304.             case _KHO :    ch = -10;    break;
  305.             case _KEN :    ch = 0x76;    break;
  306.             case 0x1B :
  307.                 wclose();
  308.                 return -1;
  309.             case '\n' :
  310.                 wclose();
  311.                 return ch+10; } }
  312. }
  313.  
  314. /*
  315.  * Prompt for YES/NO response
  316.  */
  317. yesno(ptr)
  318.     char *ptr;
  319. {
  320.     int i;
  321.  
  322.     i = strlen(ptr)+6;
  323.     wopen((80-i)/2, 10, i, 3, WSAVE|WBOX3|WCOPEN|REVERSE);
  324.     wprintf("%s ? Y", ptr);
  325.     for(;;) switch(toupper(wgetc())) {
  326.         case 'N' :
  327.         case 0x1B :
  328.             wclose();
  329.             return 0;
  330.         case '\n' :
  331.         case 'Y' :
  332.             wclose();
  333.             return 1; }
  334. }
  335.  
  336. /*
  337.  * Arrange the ICON's
  338.  */
  339. arrange()
  340. {
  341.     int i, x, y, max_icon;
  342.     unsigned v1, v2;
  343.  
  344.     for(max_icon = 0; (max_icon < MAXPACK) && test_icon(max_icon); ++max_icon);
  345.     for(i = max_icon+1; i < MAXPACK; ++i) {
  346.         if(test_icon(i)) {
  347.             load_icon(i);
  348.             save_icon(max_icon++); } }
  349.         
  350.     wopen(0, 0, 80, 25, WSAVE|WCOPEN|NORMAL);
  351.     wcursor_off();
  352.     wgotoxy(0, 24);
  353.     wprintf("nn SPACE nn ENTER to exchange, ESC to exit.");
  354.  
  355. redraw:
  356.     /* Draw the ICONs */
  357.     for(i=x=y=0; i < max_icon; ++i) {
  358.         draw_icon(x, y, Itext[i], Iattr[i]);
  359.         *W_OPEN = NORMAL;
  360.         wgotoxy(x+3, y+6);
  361.         wprintf("%2u", i+1);
  362.         if((x += 9) > 79) {
  363.             x = 0;
  364.             y += 8; } }
  365.  
  366.     v1 = v2 = 0;
  367.     for(;;) {
  368.         wgotoxy(77, 24);
  369.         wprintf("%-2u", v1);
  370.         switch(i = wgetc()) {
  371.             case 0x1B :
  372.                 wclose();
  373.                 return;
  374.             case '\n' :
  375.                 if(v1 && v2) {
  376.                     if((v1 - 1) >= max_icon)
  377.                         break;
  378.                     --v2;
  379.                     load_icon(--v1);
  380.                     memcpy(Itext[v1], Itext[v2], sizeof(itext));
  381.                     memcpy(Iattr[v1], Iattr[v2], sizeof(iattr));
  382.                     memcpy(Idir [v1], Idir [v2], sizeof(idir ));
  383.                     memcpy(Icmd [v1], Icmd [v2], sizeof(icmd ));
  384.                     save_icon(v2); }
  385.                 v1 = v2 = 0;
  386.                 wclwin();
  387.                 goto redraw;
  388.             case '0' :
  389.             case '1' :
  390.             case '2' :
  391.             case '3' :
  392.             case '4' :
  393.             case '5' :
  394.             case '6' :
  395.             case '7' :
  396.             case '8' :
  397.             case '9' :
  398.                 v1 = ((v1 % 10) * 10) + (i - '0');
  399.                 break;
  400.             case ' ' :
  401.                 if((v1 - 1) < max_icon) {
  402.                     wgotoxy(77-16, 24);
  403.                     wprintf("Exchange %-2u and ", v2 = v1);
  404.                     v1 = 0; } } }
  405. }
  406.  
  407. /*
  408.  * Get a filename with extension only if necessary
  409.  */
  410. get_name(dest, name, ext)
  411.     char *dest, *name, *ext;
  412. {
  413.     char c, flag;
  414.  
  415.     flag = -1;
  416.     while(*dest = c = *name++) {
  417.         ++dest;
  418.         if(c == '.')
  419.             flag = 0; }
  420.  
  421.     if(flag)
  422.         while(*dest++ = *ext++);
  423. }
  424.